{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 卷积网络的训练数据为MNIST\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_epochs    = 2     # 训练轮数\n",
    "batch_size      = 100     # 随机抽取数据大小\n",
    "display_step    = 1       # 显示训练结果的间隔\n",
    "learning_rate   = 0.0001  # 学习效率\n",
    "fch_nodes       = 512     # 全连接隐藏层神经元的个数\n",
    "train_keep_prob = 0.5     # 全连接层正则化参数\n",
    "c1_kernel       = [5, 5, 1, 16]\n",
    "c2_kernel       = [5, 5, 16, 32]\n",
    "p1_ksize        = [1, 2, 2, 1]\n",
    "p2_ksize        = [1, 2, 2, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 训练参数\n",
    "train_epochs    = 100     # 训练轮数\n",
    "batch_size      = 100     # 随机抽取数据大小\n",
    "display_step    = 1       # 显示训练结果的间隔\n",
    "learning_rate   = 0.0001  # 学习效率\n",
    "fch_nodes       = 512     # 全连接隐藏层神经元的个数\n",
    "train_keep_prob = 0.5     # 全连接层正则化参数\n",
    "c1_kernel       = [5, 5, 1, 16]\n",
    "c2_kernel       = [5, 5, 16, 32]\n",
    "p1_ksize        = [1, 2, 2, 1]\n",
    "p2_ksize        = [1, 2, 2, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 卷积网络结构\n",
    "# 输入层为输入的灰度图像尺寸:  -1 x 28 x 28 x 1 \n",
    "# 第一个卷积层,卷积核的大小,深度和数量 (5, 5, 1, 16)\n",
    "# 池化后的特征张量尺寸:       -1x 14 x 14 x 16\n",
    "# 第二个卷积层,卷积核的大小,深度和数量 (5, 5, 16, 32)\n",
    "# 池化后的特征张量尺寸:       -1 x 7 x 7 x 32\n",
    "# 全连接层权重矩阵         1568 x 512\n",
    "# 输出层与全连接隐藏层之间,  512 x 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 网络模型需要的一些辅助函数\n",
    "# 权重初始化(卷积核初始化)\n",
    "# tf.truncated_normal()不同于tf.random_normal(),返回的值中不会偏离均值两倍的标准差\n",
    "# 参数shpae为一个列表对象,例如[5, 5, 1, 32]对应\n",
    "# 5,5 表示卷积核的大小, 1代表通道channel,对彩色图片做卷积是3,单色灰度为1\n",
    "# 最后一个数字32,卷积核的个数,(也就是卷基层提取的特征数量)\n",
    "#   显式声明数据类型,切记\n",
    "def weight_init(shape):\n",
    "    weights = tf.truncated_normal(shape, stddev=0.1,dtype=tf.float32)\n",
    "    return tf.Variable(weights)\n",
    "\n",
    "# 偏置的初始化\n",
    "def biases_init(shape):\n",
    "    biases = tf.random_normal(shape,dtype=tf.float32)\n",
    "    return tf.Variable(biases)\n",
    "\n",
    "# 随机选取mini_batch\n",
    "def get_random_batchdata(n_samples, batchsize):\n",
    "    start_index = np.random.randint(0, n_samples - batchsize)\n",
    "    return (start_index, start_index + batchsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 全连接层权重初始化函数xavier\n",
    "def xavier_init(layer1, layer2, constant = 1):\n",
    "    Min = -constant * np.sqrt(6.0 / (layer1 + layer2))\n",
    "    Max = constant * np.sqrt(6.0 / (layer1 + layer2))\n",
    "    return tf.Variable(tf.random_uniform((layer1, layer2), minval = Min, maxval = Max, dtype = tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 卷积\n",
    "def conv2d(x, w):\n",
    "    return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "# 源码的位置在tensorflow/python/ops下nn_impl.py和nn_ops.py\n",
    "# 这个函数接收两个参数,x 是图像的像素, w 是卷积核\n",
    "# x 张量的维度[batch, height, width, channels]\n",
    "# w 卷积核的维度[height, width, channels, channels_multiplier]\n",
    "# tf.nn.conv2d()是一个二维卷积函数,\n",
    "# stirdes 是卷积核移动的步长,4个1表示,在x张量维度的四个参数上移动步长\n",
    "# padding 参数'SAME',表示对原始输入像素进行填充,卷积后映射的2D图像与原图大小相等\n",
    "# 填充,是指在原图像素值矩阵周围填充一圈0像素点\n",
    "# 如果不进行填充,假设 原图为 32x32 的图像,卷积和大小为 5x5 ,卷积后映射图像大小 为 28x28"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 池化\n",
    "def max_pool_2x2(x, ksize):\n",
    "    return tf.nn.max_pool(x, ksize= ksize, strides=[1, 2, 2, 1], padding='SAME')\n",
    "\n",
    "# 池化跟卷积的情况有点类似\n",
    "# x 是卷积后,有经过非线性激活后的图像,\n",
    "# ksize 是池化滑动张量\n",
    "# ksize 的维度[batch, height, width, channels],跟 x 张量相同\n",
    "# strides [1, 2, 2, 1],与上面对应维度的移动步长\n",
    "# padding与卷积函数相同,padding='VALID',对原图像不进行0填充"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# x 是手写图像的像素值,y 是图像对应的标签\n",
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "y = tf.placeholder(tf.float32, [None, 10])\n",
    "# 把灰度图像一维向量,转换为28x28二维结构\n",
    "x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "# -1表示任意数量的样本数,大小为28x28深度为一的张量\n",
    "# 可以忽略(其实是用深度为28的,28x1的张量,来表示28x28深度为1的张量)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 第一层卷积+池化\n",
    "w_conv1 = weight_init(c1_kernel)                             # 5x5,深度为1,16个\n",
    "b_conv1 = biases_init([c1_kernel[-1]])\n",
    "h_conv1 = tf.nn.relu(conv2d(x_image, w_conv1) + b_conv1)    # 输出张量的尺寸:28x28x16\n",
    "h_pool1 = max_pool_2x2(h_conv1, p1_ksize)                       # 池化后张量尺寸:14x14x16\n",
    "# h_pool1 , 14x14的16个特征图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 第二层卷积+池化\n",
    "w_conv2 = weight_init(c2_kernel)                             # 5x5,深度为16,32个\n",
    "b_conv2 = biases_init([c2_kernel[-1]])\n",
    "h_conv2 = tf.nn.relu(conv2d(h_pool1, w_conv2) + b_conv2)    # 输出张量的尺寸:14x14x32\n",
    "h_pool2 = max_pool_2x2(h_conv2, p2_ksize)                                   # 池化后张量尺寸:7x7x32\n",
    "# h_pool2 , 7x7的32个特征图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 全连接层\n",
    "# h_pool2是一个7x7x32的tensor,将其转换为一个一维的向量\n",
    "h_fpool2 = tf.reshape(h_pool2, [-1, 7*7*32])\n",
    "# 全连接层,隐藏层节点为512个\n",
    "# 权重初始化\n",
    "w_fc1 = xavier_init(7*7*32, fch_nodes)\n",
    "b_fc1 = biases_init([fch_nodes])\n",
    "h_fc1 = tf.nn.relu(tf.matmul(h_fpool2, w_fc1) + b_fc1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 全连接隐藏层/输出层\n",
    "# 为了防止网络出现过拟合的情况,对全连接隐藏层进行 Dropout(正则化)处理,在训练过程中随机的丢弃部分\n",
    "# 节点的数据来防止过拟合.Dropout同把节点数据设置为0来丢弃一些特征值,仅在训练过程中,\n",
    "# 预测的时候,仍使用全数据特征\n",
    "# 传入丢弃节点数据的比例\n",
    "keep_prob = tf.placeholder(tf.float32)\n",
    "h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "\n",
    "# 隐藏层与输出层权重初始化\n",
    "w_fc2 = xavier_init(fch_nodes, 10)\n",
    "b_fc2 = biases_init([10])\n",
    "\n",
    "# 未激活的输出\n",
    "y_ = tf.add(tf.matmul(h_fc1_drop, w_fc2), b_fc2)\n",
    "# 激活后的输出\n",
    "y_out = tf.nn.softmax(y_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 交叉熵代价函数\n",
    "cross_entropy = tf.reduce_mean(-tf.reduce_sum(y * tf.log(y_out), reduction_indices = [1]))\n",
    "\n",
    "# tensorflow自带一个计算交叉熵的方法\n",
    "# 输入没有进行非线性激活的输出值 和 对应真实标签\n",
    "#cross_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_, y))\n",
    "\n",
    "# 优化器选择Adam(有多个选择)\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cross_entropy)\n",
    "\n",
    "# 准确率\n",
    "# 每个样本的预测结果是一个(1,10)的vector\n",
    "correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_out, 1))\n",
    "# tf.cast把bool值转换为浮点数\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 全局变量进行初始化的Operation\n",
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-15-608ecd15d39a>:2: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /home/jinghui/anaconda2/envs/tensorflow/lib/python2.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /home/jinghui/anaconda2/envs/tensorflow/lib/python2.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting MNIST/mnist/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /home/jinghui/anaconda2/envs/tensorflow/lib/python2.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting MNIST/mnist/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/jinghui/anaconda2/envs/tensorflow/lib/python2.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting MNIST/mnist/t10k-images-idx3-ubyte.gz\n",
      "Extracting MNIST/mnist/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/jinghui/anaconda2/envs/tensorflow/lib/python2.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: __init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n"
     ]
    }
   ],
   "source": [
    "# 加载数据集MNIST\n",
    "mnist = input_data.read_data_sets('MNIST/mnist', one_hot=True)\n",
    "n_samples = int(mnist.train.num_examples)\n",
    "#total_batches = int(n_samples / batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess = tf.Session()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch : 10 , Train cost: 2.3045609\n",
      "Epoch : 11 , Train cost: 1.9697182\n",
      "training finished\n"
     ]
    }
   ],
   "source": [
    "Train_cost = []\n",
    "\n",
    "for i in range(train_epochs):\n",
    "    # 随机抽取batch data 的次数\n",
    "    for j in range(50):\n",
    "        start_index, end_index = get_random_batchdata(n_samples, batch_size)\n",
    "            \n",
    "        batch_x = mnist.train.images[start_index: end_index]\n",
    "        batch_y = mnist.train.labels[start_index: end_index]\n",
    "        _ , cost= sess.run([ optimizer,cross_entropy], feed_dict={x:batch_x, y:batch_y,keep_prob:train_keep_prob})\n",
    "        Train_cost.append(cost)\n",
    "    \n",
    "    if i % display_step ==0:\n",
    "        print ('Epoch : %d , Train cost: %.7f'%(i+10,cost))\n",
    "print 'training finished'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 学习曲线\n",
    "fig2,ax2 = plt.subplots(figsize=(10,5))\n",
    "plt.plot(Train_cost, label='Train')\n",
    "ax2.set_xlabel('Epochs')\n",
    "ax2.set_ylabel('Cost')\n",
    "plt.title('train cost')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Test 结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test result is: 0.6373333\n"
     ]
    }
   ],
   "source": [
    "accu = sess.run(accuracy, feed_dict={x:mnist.test.images[:3000],y:mnist.test.labels[:3000] , keep_prob:1.0})\n",
    "    \n",
    "print ('Test result is: %.7f'%(accu))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "input image的可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# imput image\n",
    "fig2,ax2 = plt.subplots(figsize=(2,2))\n",
    "ax2.imshow(np.reshape(mnist.train.images[11], (28, 28)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x72 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 第一层的卷积输出的特征图\n",
    "input_image = mnist.train.images[11:12]\n",
    "conv1_16 = sess.run(h_conv1, feed_dict={x:input_image})          # [16, 28, 28 ,1] \n",
    "conv1_transpose = sess.run(tf.transpose(conv1_16, [3,0,1,2]))\n",
    "fig3,ax3 = plt.subplots(nrows=1, ncols=16, figsize = (16,1))\n",
    "for i in range(16):\n",
    "    ax3[i].imshow(conv1_transpose[i][0])                          # tensor的切片[batch, channels, row, column] \n",
    "plt.title('Conv1 16x28x28')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 28, 28, 16)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv1_16.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, 1, 28, 28)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv1_transpose.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJIAAACPCAYAAAARM4LLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAACMZJREFUeJzt3W9sVfUZB/Dv00JB26GFCkOKwiJgyowSGKCwxQS6YaNTkRm6bHFJx5aom86OKbg3m4sjW+aSJXOTOeZeENGgs8w1uCEisikWpnNVaQEzpVCpVQYMGNLy7MU91PucedvLvU/PObf3+0ma3ufc23t+ab4959fz57miqiDKV0ncA6ChgUEiFwwSuWCQyAWDRC4YJHLBIJELBolc5BUkEVkkIm0iskdE7vEaFBUeyfXItoiUAmgHUAugA0ALgHpVfSPTz5TJCB2J8pzWR/E4ikPdqnrBQK8blsc6ZgPYo6pvAYCIrANwPYCMQRqJcsyRBXmskqK2Sde/nc3r8tm1TQCwL63uCJYZIvINEdkhIjtO4WQeq6MkG/TJtqquVtVZqjprOEYM9uooJvkEaT+AiWl1dbCMilA+QWoBMEVEJotIGYClADb4DIsKTc6TbVXtEZHbATwDoBTAGlV93W1kVFDy+a8NqtoMoNlpLFTAeGSbXDBI5IJBIhcMErlgkMgFg0QuGCRywSCRi7wOSA4lPQtmmvr96fYE84mx9rotveRY3+O7L/+zea7hvHdNvfG4fa/lqxtMfeFP/nZ2g00gbpHIBYNELop213b4K3NNvXnVL0w9Quyv5jQyX5JcAjH1qdDlywvOOW7qbd/+mamvKm00dfWPC29Xxy0SuWCQyAWDRC6Kdo505Ib/mHq4lJo6PCd6p+eEqe/t+GLG996+61P2vcs/NPW2eb8y9VU3/MPU+x6whwv0ZPJvmuAWiVwwSOSCQSIXRTtHmrTM3jl168bPmbr1g0+auvIO+/O97XszvvdUfNDvuuf8+jumbr/OzpmuaPyWqavvT/5xJW6RyAWDRC4YJHJRtHOk3kOHTP3Kb6409fl77bGb3va/u6279Fj/f7/T69pMffh+t1UPGm6RyAWDRC4YJHJRtHOksDEPvxj3EPpcW2XPva1FdUwjyR63SORiwCCJyBoR6RKR1rRlo0XkLyKyO/heObjDpKTLZov0CIBFoWX3AHhWVacAeDaoqYgNOEdS1a0iMim0+HoAVwePfw9gC4C7Hcc1pJy85jOm/lrtln5f/1TXjNCS93wHNAhynSONU9XO4PG7AMY5jYcKVN6TbU11fM94iwXbIxeHXIN0UETGA0DwvSvTC9keuTjkehxpA4BbAKwKvje5jagAlY4aZeqD9dNN/c077a+nYVSHqf8Vuh78/Z9ONvXIoTBHEpFHAbwIYJqIdIhIA1IBqhWR3QAWBjUVsWz+a6vP8BQ/VIT68Mg2ueC5tgxKrqgx9YGrzzf1kWk9fY+XzXvePLd8zHMDvLvtFbCw+S5TT/3jy1mOMjm4RSIXDBK5YJDIRdHMkYaNt/ep3fK8vf7oC+fadn3DYecp4d4A+Zj/3VtNPfWxFrf3jgu3SOSCQSIXRbNr00p7GuPG8vBt1WWRjUXCp7hP90a27sHCLRK5YJDIBYNELopmjoROeynGnJ1fNvWMsbbNzQubLzP1OQftaY10J8bZSc8Pb1pn6psquk1dt3KLqZv7rlpO+cS6lzKuK6m4RSIXDBK5YJDIhahm/mgEb6NktM6RoX89XPh0zL9/d66pN1/2mKmv3bXY1CW1B+wbxnicaZOu36mqswZ6HbdI5IJBIhcMErkonuNIEerptJekVIQ6JzS2zDd186VPmXrusttNXfVQclruZMItErlgkMgFg0QuhswcqbTS9vrSD+1HW50+dgxJsXGrbVvz86X2IyJuvM3ezvTCQyMHfUz54haJXDBI5IJBIhcFO0caNtG2DK5pstcTPd1kPxLioh9E91FVMsL2gXpn+UxTf6/OHjcKu6isO7SE7ZGpSGTTH2miiDwnIm+IyOsickewnC2SqU82W6QeAI2qWgNgLoDbRKQGbJFMabJptNUJoDN4fFRE3gQwATG3SD48e4KpV43bYOqVX/+rqWdW2Y//nPbwkbzW/9aXPmpzc6rytHnuvoXrTX1zhZ2flYTa2tifBh68b4mpz0Pyr+E+qzlS0G97BoDtYItkSpN1kESkAsATAO5UVfPn3F+LZLZHLg5ZBUlEhiMVorWq+mSwOKsWyWyPXBwGnCOJiAD4LYA3VfWBtKdibZFcvt+2FP5R96dN/f2qVlO3LX7Q1CWLw/MUu0H9/3lM5mvbz+a1ANDVe9zU85oaTT11/Sumju6q+txlc0ByHoCvAviniLwaLFuJVIAeD9olvw3g5sEZIhWCbP5r24Zw98yPDP1bQigrPLJNLgr2XBtees2UW++y59Y+v+ISUz95qb2XrELsxD88zwnrbx609uhY89ySCntf2vSNttXfxX+w7zXlT9tNXQhzojBukcgFg0QuGCRyUTT3/v/3utmmPlBvr+l++bP2ONOStqWm7n7aXhMkaSfILly7yzx38nL7MVnDNu88q7EmCe/9p0gxSOSiaHZtlBvu2ihSDBK5YJDIBYNELhgkcsEgkQsGiVwwSOSCQSIXDBK5YJDIBYNELhgkcsEgkQsGiVxEej2SiLyH1F25VQDC/e2SIqlji2tcF6vqBQO9KNIg9a1UZEc2F0vFIaljS+q4zuCujVwwSOQiriCtjmm92Ujq2JI6LgAxzZFo6OGujVxEGiQRWSQibSKyR0RibacsImtEpEtEWtOWJaJ3eCH2No8sSCJSCuCXAK4BUAOgPujXHZdHAIQ+JDQxvcMLr7e5qkbyBeBKAM+k1SsArIhq/RnGNAlAa1rdBmB88Hg8gLY4x5c2riYAtUkdn6pGumubAGBfWt0RLEuSxPUOL5Te5pxsZ6CpP/tY/6XNtbd5HKIM0n4AE9Pq6mBZkmTVOzwK+fQ2j0OUQWoBMEVEJotIGYClSPXqTpIzvcOBGHqHn5FFb3MgxvF9rIgnjXUA2gHsBXBvzBPYR5H6sJ5TSM3XGgCMQeq/od0ANgEYHdPY5iO123oNwKvBV11SxvdxXzyyTS442SYXDBK5YJDIBYNELhgkcsEgkQsGiVwwSOTifxwXUdaD48yeAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x72 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x72 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2304x144 with 32 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2304x72 with 32 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# imput image\n",
    "fig2,ax2 = plt.subplots(figsize=(2,2))\n",
    "ax2.imshow(np.reshape(mnist.train.images[11], (28, 28)))\n",
    "plt.show()\n",
    "\n",
    "#第一个卷基层\n",
    "\n",
    "# 第一层的卷积输出的特征图\n",
    "input_image = mnist.train.images[11:12]\n",
    "conv1_16 = sess.run(h_conv1, feed_dict={x:input_image})          # [16, 28, 28 ,1] \n",
    "conv1_transpose = sess.run(tf.transpose(conv1_16, [3,0,1,2]))\n",
    "fig3,ax3 = plt.subplots(nrows=1, ncols=16, figsize = (16,1))\n",
    "for i in range(16):\n",
    "    ax3[i].imshow(conv1_transpose[i][0][:,:])                          # tensor的切片[batch, channels, row, column] \n",
    "plt.title('Conv1 16x28x28')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "#第一个池化层\n",
    "\n",
    "# 第一层池化后的特征图\n",
    "pool1_16 = sess.run(h_pool1, feed_dict={x:input_image})          # [16, 14, 14, 1]\n",
    "pool1_transpose = sess.run(tf.transpose(pool1_16, [3,0,1,2]))\n",
    "fig4,ax4 = plt.subplots(nrows=1, ncols=16, figsize=(16,1))\n",
    "for i in range(16):\n",
    "    ax4[i].imshow(pool1_transpose[i][0])\n",
    "plt.title('Pool1 16x14x14')\n",
    "plt.show()\n",
    "\n",
    "#第二层卷积\n",
    "\n",
    "# 第二层卷积输出特征图\n",
    "conv2_32 = sess.run(h_conv2, feed_dict={x:input_image})          # [32, 14, 14, 1]\n",
    "conv2_transpose = sess.run(tf.transpose(conv2_32, [3,0,1,2]))\n",
    "fig5,ax5 = plt.subplots(nrows=1, ncols=32, figsize = (32, 2))\n",
    "for i in range(32):\n",
    "    ax5[i].imshow(conv2_transpose[i][0])\n",
    "plt.title('Conv2 32x14x14')\n",
    "plt.show()\n",
    "\n",
    "#第二层池化\n",
    "\n",
    "# 第二层池化后的特征图\n",
    "pool2_32 = sess.run(h_pool2, feed_dict={x:input_image})          # [32, 7, 7, 1]\n",
    "pool2_transpsoe = sess.run(tf.transpose(pool2_32, [3,0,1,2]))\n",
    "fig6,ax6 = plt.subplots(nrows=1, ncols=32, figsize = (32, 1))\n",
    "plt.title('Pool2 32x7x7')\n",
    "for i in range(32):\n",
    "    ax6[i].imshow(pool2_transpsoe[i][0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "images = []\n",
    "for i in range(1000):\n",
    "    image = plt.imread('xxx/'+str(i)+'.jpg')\n",
    "    images.append(image)\n",
    "images = np.array(images)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tensorflow]",
   "language": "python",
   "name": "conda-env-tensorflow-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
